home *** CD-ROM | disk | FTP | other *** search
/ Aminet 39 / Aminet 39 (2000)(Schatztruhe)[!][Oct 2000].iso / Aminet / game / shoot / Orbit_src.lha / Orbit / source / server.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-07-04  |  21.4 KB  |  1,115 lines
  1. /*
  2.     Amiga port by Oliver Gantert
  3.  
  4.     27.04.2000 - fixed some compiler warnings
  5.     28.04.2000 - commented out some functions, no networking on Amiga yet
  6. */
  7. /* 
  8.  
  9. ORBIT, a freeware space combat simulator 
  10. Copyright (C) 1999  Steve Belczyk <steve1@genesis.nred.ma.us> 
  11.  
  12. This program is free software; you can redistribute it and/or 
  13. modify it under the terms of the GNU General Public License 
  14. as published by the Free Software Foundation; either version 2 
  15. of the License, or (at your option) any later version. 
  16.  
  17. This program is distributed in the hope that it will be useful, 
  18. but WITHOUT ANY WARRANTY; without even the implied warranty of 
  19. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
  20. GNU General Public License for more details. 
  21.  
  22. You should have received a copy of the GNU General Public License 
  23. along with this program; if not, write to the Free Software 
  24. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. 
  25.  
  26. */ 
  27.  
  28. #include "orbit.h"
  29.  
  30. #ifndef AMIGA
  31. #ifndef WIN32
  32. #include <sys/socket.h>
  33. #include <unistd.h>
  34. #include <netinet/in.h>
  35. #include <netdb.h>
  36. #include <arpa/inet.h>
  37. #include <netinet/tcp.h>
  38. #endif /* WIN32 */
  39. #include <fcntl.h>
  40. #endif /* AMIGA */
  41.  
  42. #include <errno.h>
  43. #include <limits.h>
  44. #include <stdarg.h>
  45.  
  46. /*
  47.  *  All sorts of stuff the server does
  48.  */
  49.  
  50. void DoServer()
  51. /*
  52.  *  I am an ORBIT server
  53.  */
  54. {
  55.   int c;
  56.  
  57.   /* Look for any new clients */
  58.   CheckForClient();
  59.  
  60.   /* Loop through clients */
  61.   for (c=0; c<NCLIENTS; c++)
  62.   {
  63.     if (client[c].active) DoThisClient (c);
  64.   }
  65. }
  66.  
  67. void DoThisClient (int c)
  68. /*
  69.  *  Server handles client c
  70.  */
  71. {
  72.   int i;
  73.  
  74.   /* Don't bother if this client is not active */
  75.   if (!client[c].active) return;
  76.  
  77.   /* Don't bother if this client is us */
  78.   if (client[c].is_me) return;
  79.  
  80.   /* Bump times */
  81.   client[c].timer.idle += deltaT;
  82.   client[c].timer.ping += deltaT;
  83.   for (i=0; i<NCLIENTS; i++) client[c].timer.posn[i] += deltaT;
  84.   client[c].timer.rollcall += deltaT;
  85.  
  86.   /* If client has been idle too long, goodbye */
  87.   if (client[c].timer.idle > MAXCLIENTIDLE)
  88.   {
  89.     Cprint ("Dropping idle client");
  90.     Log ("DoThisClient: Dropping idle client %d", c);
  91.     DropClient (c);
  92.     return;
  93.   }
  94.  
  95.   /* See if this client has anything to say to us */
  96.   ReadFromClient (c);
  97.  
  98.   /* Send anything we have to send to this client */
  99.   SendToClient (c);
  100. }
  101.  
  102. void SendToClient (int c)
  103. /*
  104.  *  Send anything we have to send to this client
  105.  */
  106. {
  107.   int cc;
  108.  
  109.   if (!client[c].active) return;
  110.  
  111.   /* Time to send ping? */
  112.   if (client[c].timer.ping >= PINGINTERVAL)
  113.   {
  114.     client[c].timer.ping = 0.0;
  115.     SendASCIIPacket (client[c].socket,
  116.     "PING %lf\n", absT);
  117.   }
  118.  
  119.  /* Time to send position reports? */
  120.  for (cc=0; cc<NCLIENTS; cc++)
  121.  {
  122.   /* Not if it's us and we're dead */
  123.   if ( (cc == server.client) &&
  124.        ((state == STATE_DEAD1) || (state == STATE_DEAD2)) ) continue;
  125.  
  126.   if (client[cc].active && (cc != c))
  127.   {
  128.    if (client[c].timer.posn[cc] > client[c].posninterval)
  129.    {
  130.     /* Report client cc's position to client c */
  131.     SendPosition (c, cc);
  132.     client[c].timer.posn[cc] = 0.0;
  133.    }
  134.   }
  135.  }
  136.  
  137.  /* Time to send roll call? */
  138.  if (client[c].timer.rollcall >= ROLLCALLINTERVAL) SendRollCall (c);
  139. /**
  140.  if (client[c].timer.posn >= client[c].posninterval)
  141.  {
  142.   client[c].timer.posn = 0.0;
  143.   SendPositions (c);
  144.  }
  145. **/
  146. }
  147.  
  148. void ReadFromClient (int c)
  149. /*
  150.  *  See if this client has anything to say to us
  151.  */
  152. {
  153. #ifndef AMIGA
  154.  char buf[1024];
  155.  int r, e;
  156.  
  157.  /* Bail if not there */
  158.  if (!client[c].active) return;
  159.  
  160.  /* Try to read from this client */
  161.  r = recv (client[c].socket, buf, 1024, 0);
  162.  
  163.  /* If recv returns zero the other side has gone away */
  164.  if (r == 0)
  165.  {
  166.   Cprint ("Client %d went away", c);
  167.   Log ("ReadFromClient: Client %d went away", c);
  168.   DropClient (c);
  169.  
  170.   return;
  171.  }
  172.  
  173.  /* If we get an error it better be EWOULDBLOCK */
  174. #ifndef WIN32
  175.  if (r < 0)
  176.  {
  177.   if (errno == EWOULDBLOCK)
  178.   {
  179.    /* All is well */
  180.    return;
  181.   }
  182.   else
  183.   {
  184.    /* Uh oh */
  185.    Log ("ReadFromClient: recv error: %d", errno);
  186.    return;
  187.   }
  188.  }
  189. #else
  190.  if (r == SOCKET_ERROR)
  191.  {
  192.   e = WSAGetLastError();
  193.   if (e == WSAEWOULDBLOCK)
  194.   {
  195.    /* All is well */
  196.    return;
  197.   }
  198.   else
  199.   {
  200.    /* Uh oh */
  201.    Log ("ReadFromClient: recv error: %d", e);
  202.    return;
  203.   }
  204.  }
  205. #endif
  206.  
  207.  /* We really have data from the client! */
  208.  client[c].timer.idle = 0.0;
  209.  
  210.  /* Handle the data */
  211.  buf[r] = 0;
  212.  recv_bytes += r;
  213. /*
  214.  Log ("ReadFromClient: Client %d data:", c);
  215.  LogWrite (buf, r);
  216. */
  217.  /* Handle packet from Client */
  218.  ClientData (c, buf, r);
  219. #endif /* AMIGA */
  220. }
  221.  
  222. void ClientData (int c, char *buf, int n)
  223. /*
  224.  *  Separate incoming data into packets
  225.  */
  226. {
  227.  int i;
  228. #ifndef BINARYPACKETS
  229.  int ch, j;
  230. #endif
  231.  
  232. #ifdef BINARYPACKETS
  233.  for (i=0; i<n; i++) ClientByte (c, buf[i]);
  234. #else
  235.  j = client[c].ptr;
  236.  
  237.  for (i=0; i<n; i++)
  238.  {
  239.   ch = client[c].pkt[j] = buf[i];
  240.   j = (j + 1) % 1024;
  241.  
  242.   /* Got a packet? */
  243.   if (ch == 0)
  244.   {
  245.    ClientPacket (c, client[c].pkt);
  246.    j = 0;
  247.   }
  248.  }
  249.  
  250.  client[c].ptr = j;
  251. #endif
  252. }
  253.  
  254. void ClientByte (int c, char b)
  255. /*
  256.  *  Process one byte from server
  257.  */
  258. {
  259.  switch (client[c].state)
  260.  {
  261.  case NETSTATE_MAGIC:
  262.   if (b == NET_MAGIC)
  263.   {
  264.    client[c].state = NETSTATE_SIZE;
  265.   }
  266.   break;
  267.  
  268.  case NETSTATE_SIZE:
  269.   client[c].remain = 0xff & b;
  270.   client[c].ptr = 0;
  271.   client[c].state = NETSTATE_PACKET;
  272.   if (client[c].remain == 0) client[c].state = NETSTATE_MAGIC;
  273.   break;
  274.  
  275.  case NETSTATE_PACKET:
  276.   client[c].pkt[client[c].ptr++] = b;
  277.   client[c].remain--;
  278.   if (client[c].remain == 0)
  279.   {
  280.    client[c].pkt[client[c].ptr] = 0;
  281.    ClientPacket (c, client[c].pkt);
  282.    client[c].state = NETSTATE_MAGIC;
  283.   }
  284.   break;
  285.  
  286.  default:
  287.   Log ("ClientByte: PANIC! No such state: %d", client[c].state);
  288.   break;
  289.  }
  290. }
  291.  
  292. void CheckForClient()
  293. /*
  294.  *  Look for a new network client
  295.  */
  296. {
  297. #ifndef AMIGA
  298.  int c, e, i, len;
  299.  SOCKET a;
  300.  int one = 1;
  301.  struct sockaddr_in sin;
  302. #ifdef WIN32 
  303.  unsigned long longone = 1; 
  304. #endif 
  305.  
  306.  len = sizeof (sin);
  307.  
  308.  /* Ask for any outstanding connections */
  309.  a = accept (server.listening_socket, (struct sockaddr *) &sin, &len);
  310.  
  311. #ifndef WIN32
  312.  if (a < 0)
  313.  {
  314.   /* If the accept failed, it better be because the socket
  315.      is non-blocking or something went wrong */
  316.   if (errno == EWOULDBLOCK)
  317.   {
  318.    /* No problem, just no new connection */
  319.    return;
  320.   }
  321.   else
  322.   {
  323.    /* Uh oh */
  324.    Log ("CheckForClient: accept() error: %d", errno);
  325.    return;
  326.   }
  327.  }
  328. #else
  329.  if (a == SOCKET_ERROR)
  330.  {
  331.   e = WSAGetLastError();
  332.   if (e == WSAEWOULDBLOCK)
  333.   {
  334.    /* All is well, no new client */
  335.    return;
  336.   }
  337.   else
  338.   {
  339.    /* Uh oh */
  340.    Log ("CheckForClient: accept() error: %d", e);
  341.    return;
  342.   }
  343.  }
  344. #endif
  345.  else
  346.  {
  347.   /* Got one! */
  348.   c = FindClient();
  349.   if (c < 0)
  350.   {
  351.    Cprint ("Too many clients!");
  352.    Log ("CheckForClient: Too many clients");
  353. #ifndef WIN32
  354.    close (a);
  355. #else
  356.    closesocket (a);
  357. #endif
  358.   }
  359.   else
  360.   { 
  361.    /* Make this socket non-blocking too */ 
  362. #ifdef WIN32 
  363.    ioctlsocket (a, FIONBIO, &longone); 
  364. #else 
  365.    fcntl (a, F_SETFL, O_NONBLOCK); 
  366. #endif 
  367.  
  368.    /* Save client IP address */
  369.    strcpy (client[c].ip, inet_ntoa(sin.sin_addr));
  370.  
  371.    Log ("CheckForClient: Client %d [%s] connected", c, client[c].ip);
  372.    Cprint ("Client %d [%s] connected", c, client[c].ip);
  373.  
  374.    /* Disable the Nagle algorithm */
  375.    setsockopt (a, IPPROTO_TCP, TCP_NODELAY, (char *) &one,
  376.     sizeof(one));
  377.  
  378.    /* Set up new client */
  379.    client[c].active = 1;
  380.    client[c].socket = a;
  381.    client[c].is_me = 0;
  382.    client[c].ping = 0.0;
  383.    client[c].posninterval = POSNINTERVALMEDIUM;
  384.    client[c].frags = 0;
  385.  
  386.    client[c].target = InitClientTarget();
  387.  
  388.    client[c].timer.idle = 0.0;
  389.    client[c].timer.ping = PINGINTERVAL;
  390.    for (i=0; i<NCLIENTS; i++) client[c].timer.posn[i] = 0.0;
  391.    client[c].timer.rollcall = 0.0;
  392.  
  393.    client[c].pkt[0] = 0;
  394.    client[c].ptr = 0;
  395.  
  396.    /* Send welcome message to new client */
  397.    SendASCIIPacket (client[c].socket, "WELC %d\n", c);
  398.    SendASCIIPacket (client[c].socket,
  399.        "MESG Welcome, client %d, to the ORBIT server.\n", c);
  400.  
  401.    /* Send current roll call */
  402.    SendRollCall (c);
  403.   }
  404.  }
  405. #endif /* AMIGA */
  406. }
  407.  
  408. void ClientPacket (int c, char *pkt)
  409. /*
  410.  *  Handle packet from this client
  411.  */
  412. {
  413.  char cmd[128];
  414.  
  415. /* Log ("ClientPacket: %s", pkt); */ 
  416.  
  417.  /* High bit of first byte means this is a binary packet */ 
  418.  if (0x80 & pkt[0]) 
  419.  { 
  420.   ClientBinaryPacket (c, pkt); 
  421.   return; 
  422.  } 
  423.  
  424.  /* Sanity check on packet */
  425.  if ( (strlen(pkt) == 0) ||
  426.       (pkt[0] == ' ') ||
  427.       (pkt[0] == '\r') ||
  428.       (pkt[0] == '\n') ||
  429.       (pkt[0] == '\t') )
  430.  {
  431.   Log ("ClientPacket: Insane packet: %s", pkt);
  432.   return;
  433.  }
  434.  
  435.  /* Extract command part */
  436.  sscanf (pkt, "%s", cmd);
  437.  
  438.  /* Dispatch */
  439.  if (!strcasecmp (cmd, "posn"))
  440.  {
  441.   ClientPosition (c, pkt, 0);
  442.   return;
  443.  }
  444.  else if (!strcasecmp (cmd, "posu"))
  445.  {
  446.   ClientPosition (c, pkt, 1);
  447.   return;
  448.  }
  449.  else if (!strcasecmp (cmd, "fire"))
  450.  {
  451.   ClientFire (c, pkt);
  452.   return;
  453.  }
  454.  else if (!strcasecmp (cmd, "ping"))
  455.  {
  456.   ClientPing (c, pkt);
  457.   return;
  458.  }
  459.  else if (!strcasecmp (cmd, "chat"))
  460.  {
  461.   ClientChat (c, pkt);
  462.   return;
  463.  }
  464.  else if (!strcasecmp (cmd, "name"))
  465.  {
  466.   ClientName (c, pkt);
  467.   return;
  468.  }
  469.  else if (!strcasecmp (cmd, "modl"))
  470.  {
  471.   ClientModel (c, pkt);
  472.   return;
  473.  }
  474.  else if (!strcasecmp (cmd, "vers"))
  475.  {
  476.   ClientVersion (c, pkt);
  477.   return;
  478.  }
  479.  else
  480.  {
  481.   Log ("ClientPacket: Unrecongized command: %s", cmd);
  482.   return;
  483.  }
  484. } 
  485.  
  486. void ClientBinaryPacket (int c, unsigned char *pkt) 
  487. /* 
  488.  *  Binary packet from client c 
  489.  */ 
  490. { 
  491.  /* Dispatch */ 
  492.  switch (pkt[0]) 
  493.  { 
  494.  case PKT_POSN: 
  495.   ClientBinaryPosition (c, &pkt[1], 0); 
  496.   break; 
  497.  
  498.  case PKT_POSU: 
  499.   ClientBinaryPosition (c, &pkt[1], 1); 
  500.   break; 
  501.  
  502.  case PKT_PING: 
  503.   ClientBinaryPing (c, &pkt[1]); 
  504.   break; 
  505.  
  506.  default: 
  507.   Log ("ClientBinaryPacket: Unrecognized packet type: 0x%x", pkt[0]); 
  508.   break; 
  509.  } 
  510. }
  511.  
  512. void ClientPing (int c, char *pkt) 
  513. /* 
  514.  *  Handle ping packet from client 
  515.  */ 
  516. { 
  517.  double t; 
  518.  
  519.  /* Extract time from packet */ 
  520.  if (1 == sscanf (pkt, "%*s %lf", &t)) 
  521.  { 
  522.   /* Compute ping round-trip time in milliseconds */ 
  523.   client[c].ping = 1000.0 * (absT - t); 
  524.  
  525.   /* Use ping time to determine how fast we send position 
  526.      reports to this client */ 
  527.   if (client[c].ping <= PINGFAST) 
  528.   { 
  529.    client[c].posninterval = POSNINTERVALSMALL; 
  530.   } 
  531.   else if (client[c].ping <= PINGSLOW) 
  532.   { 
  533.    client[c].posninterval = POSNINTERVALMEDIUM; 
  534.   } 
  535.   else 
  536.   { 
  537.    client[c].posninterval = POSNINTERVALLARGE; 
  538.   } 
  539.  } 
  540.  else 
  541.  { 
  542.   Log ("ClientPing: Malformed ping packet: %s", pkt); 
  543.  } 
  544. } 
  545.  
  546. void ClientBinaryPing (int c, char *pkt) 
  547. /* 
  548.  *  Handle binary ping packet from client 
  549.  */ 
  550. { 
  551.  double t; 
  552.  
  553.  /* Extract time from packet */ 
  554.  DecodeBinaryPacket (pkt, "F", &t); 
  555.  
  556.  /* Compute ping round-trip time in milliseconds */ 
  557.  client[c].ping = 1000.0 * (absT - t); 
  558.  
  559.  /* Use ping time to determine how fast we send position 
  560.     reports to this client */ 
  561.  if (client[c].ping <= PINGFAST) 
  562.  { 
  563.   client[c].posninterval = POSNINTERVALSMALL; 
  564.  } 
  565.  else if (client[c].ping <= PINGSLOW) 
  566.  { 
  567.   client[c].posninterval = POSNINTERVALMEDIUM; 
  568.  } 
  569.  else 
  570.  { 
  571.   client[c].posninterval = POSNINTERVALLARGE; 
  572.  } 
  573. } 
  574.  
  575. void ShowClients ()
  576. /*
  577.  *  Give list of clients
  578.  */
  579. {
  580.  int c;
  581.  char buf[4096], buf2[256];
  582.  
  583.  if (!am_server && !am_client) return;
  584.  
  585.  /* Init message string */
  586.  strcpy (buf, "Active clients:\\\\");
  587.  
  588.  /* Add info for each active client */
  589.  for (c=0; c<NCLIENTS; c++)
  590.  {
  591.   if (client[c].active)
  592.   {
  593.    if (am_server)
  594.    { 
  595.     if (c == server.client) 
  596.     { 
  597.      sprintf (buf2, "%d) %s, idle %.0lf, ping %.0lf, frags %d\\", 
  598.       c, target[client[c].target].name, 
  599.       client[c].timer.idle, client[c].ping, 
  600.       client[c].frags); 
  601.     } 
  602.     else 
  603.     {
  604.      sprintf (buf2, "%d) %s [%s], idle %.0lf, ping %.0lf, frags %d\\",
  605.       c, target[client[c].target].name,
  606.       client[c].ip, client[c].timer.idle, client[c].ping,
  607.       client[c].frags); 
  608.     }
  609.    }
  610.    else if (am_client)
  611.    {
  612.     sprintf (buf2, "%d) %s, frags %d\\",
  613.      c, target[client[c].target].name,
  614.      client[c].frags);
  615.    }
  616.  
  617.    strcat (buf, buf2);
  618.   }
  619.  }
  620.  
  621.  /* Give message */
  622.  Mprint (buf);
  623. }
  624.  
  625. void ClientName (int c, char *pkt)
  626. /*
  627.  *  Set client name
  628.  */
  629. {
  630.  int cc;
  631.  
  632.  if ( (pkt[4] == 0) || (pkt[5] == 0) ) return;
  633.  
  634.  strncpy (target[client[c].target].name, &pkt[5], 16);
  635.  target[client[c].target].name[16] = 0;
  636.  
  637.  /* Tell us */
  638.  Cprint ("%s is here", target[client[c].target].name);
  639.  
  640.  /* Tell everyone else */
  641.  for (cc=0; cc<NCLIENTS; cc++)
  642.  {
  643.   if (client[cc].active && (cc != server.client) && (c != cc) )
  644.   {
  645.    SendASCIIPacket (client[cc].socket, "HELO %d %s",
  646.     c, target[client[c].target].name);
  647.   }
  648.  }
  649. }
  650.  
  651. void ClientModel (int c, char *pkt)
  652. /*
  653.  *  Set client model
  654.  */
  655. {
  656.  char buf[128];
  657.  int m;
  658.  
  659.  Log ("ClientModel: %s", pkt);
  660.  
  661.  /* Parse out model name */
  662.  if (1 != sscanf (pkt, "%*s %s", buf))
  663.  {
  664.   Log ("ClientModel: Malformed MODL packet: %s", pkt);
  665.   return;
  666.  }
  667.  
  668.  /* Try to load model */
  669.  m = LoadModel (buf);
  670.  
  671.  /* Success? */
  672.  if (m != (-1))
  673.  {
  674.   target[client[c].target].model = m;
  675.   target[client[c].target].list = model[m].list;
  676.  }
  677.  else
  678.  {
  679.   /* Use default model */
  680.   m = LoadModel ("light2.tri");
  681.   target[client[c].target].model = m;
  682.   target[client[c].target].list = model[m].list;
  683.  }
  684. }
  685.  
  686. void ClientPosition (int c, char *pkt, int urgent) 
  687. /* 
  688.  *  Client c is telling us where it is 
  689.  */ 
  690. { 
  691.  int t, cc; 
  692.  
  693.  /* Get index of client's target */ 
  694.  t = client[c].target; 
  695.  
  696.  /* Make unhidden */ 
  697.  target[t].hidden = 0; 
  698.  
  699.  /* Parse packet */ 
  700.  if (18 != sscanf (pkt, "%*s %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf", 
  701.   &target[t].pos[0], &target[t].pos[1], &target[t].pos[2], 
  702.   &target[t].vel[0], &target[t].vel[1], &target[t].vel[2], 
  703.   &target[t].view[0], &target[t].view[1], &target[t].view[2], 
  704.   &target[t].up[0], &target[t].up[1], &target[t].up[2], 
  705.   &target[t].move_up, &target[t].move_down, 
  706.   &target[t].move_right, &target[t].move_left, 
  707.   &target[t].move_pitchright, &target[t].move_pitchleft)) 
  708.  { 
  709.   Log ("ClientPosition: Malformed POSN packet: %s", pkt); 
  710.  } 
  711.  
  712.  /* Set target's right vector */ 
  713.  Crossp (target[t].right, target[t].up, target[t].view); 
  714.  
  715.  /* If it's urgent, we must tell other clients */ 
  716.  if (urgent) 
  717.  { 
  718.   for (cc=0; cc<NCLIENTS; cc++) 
  719.   { 
  720.    if (client[cc].active && 
  721.        (cc != c) && 
  722.        (cc != server.client) ) 
  723.    { 
  724.     client[cc].timer.posn[c] =  
  725.      client[cc].posninterval; 
  726.    } 
  727.   } 
  728.  } 
  729. } 
  730.  
  731. void ClientBinaryPosition (int c, unsigned char *pkt, int urgent) 
  732. /* 
  733.  *  Client c is telling us where it is 
  734.  */ 
  735. { 
  736.  int t, cc; 
  737.  
  738.  /* Get index of client's target */ 
  739.  t = client[c].target; 
  740.  
  741.  /* Make unhidden */ 
  742.  target[t].hidden = 0; 
  743.  
  744.  /* Parse packet */ 
  745.  DecodeBinaryPacket (pkt, "VVvvffffff", target[t].pos, target[t].vel, 
  746.   target[t].view, target[t].up, 
  747.   &target[t].move_up, &target[t].move_down, 
  748.   &target[t].move_right, &target[t].move_left, 
  749.   &target[t].move_pitchright, &target[t].move_pitchleft); 
  750.  
  751.  Normalize (target[t].up); 
  752.  Normalize (target[t].view); 
  753.  
  754.  /* Set target's right vector */ 
  755.  Crossp (target[t].right, target[t].up, target[t].view); 
  756.  
  757.  /* If it's urgent, we must tell other clients */ 
  758.  if (urgent) 
  759.  { 
  760.   for (cc=0; cc<NCLIENTS; cc++) 
  761.   { 
  762.    if (client[cc].active && 
  763.        (cc != c) && 
  764.        (cc != server.client) ) 
  765.    { 
  766.     client[cc].timer.posn[c] =  
  767.      client[cc].posninterval; 
  768.    } 
  769.   } 
  770.  } 
  771. } 
  772.  
  773. void ClientVersion (int c, char *pkt)
  774. /*
  775.  *  Client c is telling us what version it is running
  776.  */
  777. {
  778.  char buf[64];
  779.  
  780.  /* Extract version from packet */
  781.  if (1 != sscanf (pkt, "%*s %s", buf))
  782.  {
  783.   Log ("ClientVersion: Malformed VERS packet: %s", pkt);
  784.   return;
  785.  }
  786.  
  787.  /* Check version number */
  788.  if (strcmp (buf, VERSION))
  789.  {
  790.   /* Not the same, notify client */
  791.   SendASCIIPacket (client[c].socket,
  792.    "MESG Server is version %s, client is version %s",
  793.    VERSION, buf);
  794.   Log ("ClientVersion: Incompatible client version: %s", buf);
  795.   Cprint ("WARNING:  Client %d is using incompatible version: %s",
  796.    c, buf);
  797.  }
  798. }
  799.  
  800. void ClientFire (int c, char *pkt)
  801. /*
  802.  *  Client c has sent a fire packet
  803.  */
  804. {
  805.  int t, w;
  806.  
  807.  /* Get client's target */
  808.  t = client[c].target;
  809.  
  810.  /* Parse packet */
  811.  if (1 != sscanf (pkt, "%*s %d", &w))
  812.  {
  813.   Log ("ClientFire: Malformed FIRE packet: %s", pkt);
  814.   return;
  815.  }
  816.  
  817.  /* Fire the missile */
  818.  FireMissile (target[t].pos, target[t].vel, target[t].view,
  819.   0, w, t);
  820.  
  821.  /* Tell everyone about it */
  822.  NetClientFires (c, w);
  823. }
  824.  
  825. void SendPositions (int clnt)
  826. /*
  827.  *  THIS IS NOT CALLED!
  828.  *
  829.  *  Send a position report to client c
  830.  */
  831. {
  832.  int c, t1, t2;
  833.  double v[3], d;
  834.  
  835.  t1 = client[clnt].target;
  836.  
  837.  /* Loop through clients */
  838.  for (c=0; c<NCLIENTS; c++)
  839.  {
  840.   if (client[c].active)
  841.   {
  842.    /* Don't tell client about itself */
  843.    if (c == clnt) continue;
  844.    if (c == server.client) continue;
  845.  
  846.    t2 = client[c].target;
  847.  
  848.    /* Figure out how far away these clients are */
  849.    Vsub (v, target[t2].pos, target[t1].pos);
  850.    d = Mag2 (v);
  851.  
  852.    /* If far away, send short position packet */
  853.    if (d > TARG_MAXRANGE2)
  854.    {
  855.     SendPositionShort (clnt, c);
  856.    }
  857.    else /* Send long packet */
  858.    {
  859.     SendPositionLong (clnt, c);
  860.    }
  861.   }
  862.  }
  863. }
  864.  
  865. void SendPosition (int clnt, int c)
  866. /*
  867.  *  Report c's position to clnt
  868.  */
  869. {
  870.  int t1, t2;
  871.  double v[3], d;
  872.  
  873.  if ((!client[clnt].active) || (!client[c].active)) return;
  874.  
  875.  t1 = client[clnt].target;
  876.  t2 = client[c].target;
  877.  
  878.  /* Determine distance */
  879.  Vsub (v, target[t2].pos, target[t1].pos);
  880.  d = Mag2 (v);
  881.  
  882.  if (d > TARG_MAXRANGE2)
  883.  {
  884.   SendPositionShort (clnt, c);
  885.  }
  886.  else
  887.  {
  888.   SendPositionLong (clnt, c);
  889.  }
  890. }
  891.  
  892. void SendPositionShort (int clnt, int c)
  893. /*
  894.  *  Send short position of client c to client clnt
  895.  */
  896. {
  897.  int t;
  898.  
  899.  t = client[c].target;
  900.  
  901. #ifdef BINARYPACKETS
  902.  SendBinaryPacket (client[clnt].socket, "ccVV", PKT_POSS, c,
  903.   target[t].pos, target[t].vel);
  904. #else
  905.  SendASCIIPacket (client[clnt].socket,
  906.   "POSS %d %lf %lf %lf %lf %lf %lf", c,
  907.   target[t].pos[0], target[t].pos[1], target[t].pos[2],
  908.   target[t].vel[0], target[t].vel[1], target[t].vel[2]);
  909. #endif
  910. }
  911.  
  912. void SendPositionLong (int clnt, int c)
  913. /*
  914.  *  Send long position of client c to client clnt
  915.  */
  916. {
  917.  int t;
  918.  
  919.  t = client[c].target;
  920.  
  921. #ifdef BINARYPACKETS
  922.  SendBinaryPacket (client[clnt].socket, "ccVVvvffffff", PKT_POSL, c,
  923.   target[t].pos, target[t].vel, target[t].view, target[t].up,
  924.   target[t].move_up, target[t].move_down,
  925.   target[t].move_right, target[t].move_left,
  926.   target[t].move_pitchright, target[t].move_pitchleft);
  927. #else
  928.  SendASCIIPacket (client[clnt].socket,
  929.   "POSL %d %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf", c,
  930.   target[t].pos[0], target[t].pos[1], target[t].pos[2],
  931.   target[t].vel[0], target[t].vel[1], target[t].vel[2],
  932.   target[t].view[0], target[t].view[1], target[t].view[2],
  933.   target[t].up[0], target[t].up[1], target[t].up[2],
  934.   target[t].move_up, target[t].move_down,
  935.   target[t].move_right, target[t].move_left,
  936.   target[t].move_pitchright, target[t].move_pitchleft);
  937. #endif
  938. }
  939.  
  940. void SendPlanets (int c)
  941. /*
  942.  *  Send planet positions to client
  943.  */
  944. {
  945.  int p;
  946.  
  947.  for (p=0; p<NPLANETS; p++)
  948.  { 
  949. #ifdef BINARYPACKETS 
  950.   SendBinaryPacket (client[c].socket, "ccF", PKT_PLAN, p, planet[p].theta); 
  951. #else
  952.   SendASCIIPacket (client[c].socket, "PLAN %d %lf", p, planet[p].theta); 
  953. #endif
  954.  }
  955.  
  956.  SendASCIIPacket (client[c].socket, "RPLN");
  957. }
  958.  
  959. void SendRollCall (int c)
  960. /*
  961.  *  Send roll call to client c
  962.  */
  963. {
  964.  int cc, t;
  965.  
  966.  /* Reset timer */
  967.  client[c].timer.rollcall = 0.0;
  968.  
  969.  for (cc=0; cc<NCLIENTS; cc++)
  970.  {
  971.   /* Send name if client active */
  972.   if (client[cc].active)
  973.   {
  974.    t = client[cc].target;
  975.  
  976.    if (t >= 0)
  977.    {
  978.     /* Send name */
  979.     SendASCIIPacket (client[c].socket,
  980.      "NAME %d %s %d", cc, target[t].name, client[cc].frags);
  981.  
  982.     /* Send model */
  983.     if (cc != server.client)
  984.     {
  985.      SendASCIIPacket (client[c].socket,
  986.       "MODL %d %s", cc, model[target[t].model].name);
  987.     }
  988.     else
  989.     {
  990.      SendASCIIPacket (client[c].socket,
  991.       "MODL %d %s", cc, player.model);
  992.     }
  993.    }
  994.   }
  995.   else
  996.   { 
  997. #ifndef BINARYPACKETS
  998.    /* Show unused */
  999.    SendASCIIPacket (client[c].socket,
  1000.     "VCNT %d", cc); 
  1001. #endif
  1002.   }
  1003.  } 
  1004.  
  1005. #ifdef BINARYPACKETS 
  1006.  /* Send vacant slots to client */ 
  1007.  SendBinaryVacant (c); 
  1008. #endif
  1009.  
  1010.  /* Send flags while we're here */
  1011.  SendFlags (c); 
  1012.  
  1013.  /* Oh and what the heck, let's send planet positions too */ 
  1014.  SendPlanets (c);
  1015. } 
  1016.  
  1017. void SendBinaryVacant (int c)
  1018. /* 
  1019.  *  Send binary vacancy report to client c 
  1020.  */ 
  1021. { 
  1022.  int cc; 
  1023.  unsigned int w, bit, i1, i2; 
  1024.  
  1025.  w = 0; 
  1026.  bit = 1; 
  1027.  
  1028.  /* Make bitmask */ 
  1029.  for (cc=0; cc<NCLIENTS; cc++) 
  1030.  { 
  1031.   if (client[cc].active) w += bit; 
  1032.   bit = bit * 2; 
  1033.  } 
  1034.  
  1035.  /* Split into bytes */ 
  1036.  i1 = w % 256; 
  1037.  i2 = w / 256; 
  1038.  
  1039.  /* Send the packet */ 
  1040.  SendBinaryPacket (client[c].socket, "ccc", PKT_VCNT, i1, i2); 
  1041. }
  1042.  
  1043. void ClientChat (int c, char *pkt)
  1044. /*
  1045.  *  Client sent chat message
  1046.  */
  1047. {
  1048.  int cc;
  1049.  
  1050.  /* Sanity */
  1051.  if ( (pkt[4] == 0) || (pkt[5] == 0) || (strlen(pkt) > TEXTSIZE) ) return;
  1052.  
  1053.  /* Show the message to us */
  1054.  Cprint ("%s: %s", target[client[c].target].name, &pkt[5]);
  1055.  if (sound) PlayAudio (SOUND_COMM);
  1056.  
  1057.  /* Send to other clients */
  1058.  for (cc=0; cc<NCLIENTS; cc++)
  1059.  {
  1060.   if (client[cc].active && (cc != server.client) && (cc != c) )
  1061.   {
  1062.    SendASCIIPacket (client[cc].socket, "CMSG %s: %s",
  1063.     target[client[c].target].name, &pkt[5]);
  1064.   }
  1065.  }
  1066. }
  1067.  
  1068. void SendFlags()
  1069. /*
  1070.  *  Send gravity, etc., flags to clients
  1071.  */
  1072. {
  1073.  int c, f;
  1074.  
  1075.  /* Set flags */
  1076.  f = 0;
  1077.  if (gravity) f |= FLAG_GRAVITY;
  1078.  if (player.flightmodel == FLIGHT_ARCADE) f |= FLAG_FLIGHTMODEL;
  1079.  if (fullstop) f |= FLAG_FULLSTOP; 
  1080.  if (realdistances) f |= FLAG_REALDISTANCES; 
  1081.  if (orbit) f |= FLAG_ORBIT;
  1082.  
  1083.  /* Send em */
  1084.  for (c=0; c<NCLIENTS; c++)
  1085.  {
  1086.   if (client[c].active && (c != server.client) )
  1087.   {
  1088.    SendASCIIPacket (client[c].socket, "FLAG %d", f);
  1089.   }
  1090.  }
  1091. }
  1092.  
  1093. void DoDrop ()
  1094. /*
  1095.  *  Server admin wants to drop a client
  1096.  */
  1097. {
  1098.  int c;
  1099.  
  1100.  if (!am_server) return;
  1101.  
  1102.  c = atoi (text.buf);
  1103.  
  1104.  /* Check and drop if okay */
  1105.  if ( (c < 0) || (c >= NCLIENTS) || (!client[c].active) ||
  1106.   client[c].is_me)
  1107.  {
  1108.   Mprint ("No such client: %d", c);
  1109.   return;
  1110.  }
  1111.  
  1112.  DropClient (c);
  1113.  Cprint ("Dropped client %d", c);
  1114. }
  1115.